home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_300 / 335_02 / as7000.y < prev    next >
Encoding:
Lex Description  |  1990-12-02  |  36.9 KB  |  1,660 lines
  1. %{
  2.  
  3. /*
  4. HEADER:     ;
  5. TITLE:         Frankenstein Cross Assemblers;
  6. VERSION:     2.0;
  7. DESCRIPTION: "    Reconfigurable Cross-assembler producing Intel (TM)
  8.         Hex format object records.  ";
  9. KEYWORDS:     cross-assemblers, 1805, 2650, 6301, 6502, 6805, 6809, 
  10.         6811, tms7000, 8048, 8051, 8096, z8, z80;
  11. SYSTEM:     UNIX, MS-Dos ;
  12. FILENAME:     as7000.y;
  13. WARNINGS:     "The language defined in this file does
  14.         not follow the standard Texas Instruments syntax.
  15.  
  16.         This software is in the public domain.  
  17.         Any prior copyright claims are relinquished.  
  18.  
  19.         This software is distributed with no warranty whatever.  
  20.         The author takes no responsibility for the consequences 
  21.         of its use.
  22.  
  23.         Yacc (or Bison) required to compile."  ;
  24. SEE-ALSO:     as7000.doc,frasmain.c;    
  25. AUTHORS:     Mark Zenier;
  26. COMPILERS:     Microport Sys V/AT, ATT Yacc, Turbo C V1.5, Bison (CUG disk 285)
  27.         (previous versions Xenix, Unisoft 68000 Version 7, Sun 3);
  28. */
  29. /* TMS7000 instruction generation file */
  30. /* November 17, 1990 */
  31.  
  32. /*
  33.     description    frame work parser description for framework cross
  34.             assemblers
  35.     history        February 2, 1988
  36.             September 11, 1990 - merge table definition
  37.             September 12, 1990 - short file names
  38.             September 14, 1990 - short variable names
  39.             September 17, 1990 - use yylex as external
  40. */
  41. #include <stdio.h>
  42. #include "frasmdat.h"
  43. #include "fragcon.h"
  44.  
  45. #define yylex lexintercept
  46.  
  47.  /*    0000.0000.0000.00xx */
  48. #define    DSTMASK        0x3
  49. #define    DSTA        0x1
  50. #define    DSTB        0x2
  51.  /*     0000.0000.0000.xx00 */
  52. #define    SRCMASK        0xc
  53. #define    SRCA        0x4
  54. #define    SRCB        0x8
  55. #define ST_INH 0x1
  56. #define ST_EXPR 0x2
  57. #define ST_EXPR2 0x4
  58. #define ST_EXPR3 0x8
  59. #define ST_IEXPR2 0x10
  60. #define ST_IEXPR3 0x20
  61. #define ST_INDEX 0x40
  62. #define ST_IMMIND 0x80
  63. #define ST_RINDIR 0x100
  64. #define ST_STATUS 0x200
  65.     
  66.     static int operselbits;
  67.     static char    genbdef[] = "[1=];";
  68.     static char    genwdef[] = "[1=]x"; /* x for normal, y for byte rev */
  69.     char ignosyn[] = "[Xinvalid syntax for instruction";
  70.     char ignosel[] = "[Xinvalid operands/illegal instruction for cpu";
  71.  
  72.     long    labelloc;
  73.     static int satsub;
  74.     int    ifstkpt = 0;
  75.     int    fraifskip = FALSE;
  76.  
  77.     struct symel * endsymbol = SYMNULL;
  78.  
  79. %}
  80. %union {
  81.     int    intv;
  82.     long     longv;
  83.     char    *strng;
  84.     struct symel *symb;
  85. }
  86.  
  87. %token STATUS
  88. %token <intv> REG
  89. %token <intv> KOC_BDEF
  90. %token <intv> KOC_ELSE
  91. %token <intv> KOC_END
  92. %token <intv> KOC_ENDI
  93. %token <intv> KOC_EQU
  94. %token <intv> KOC_IF
  95. %token <intv> KOC_INCLUDE
  96. %token <intv> KOC_ORG
  97. %token <intv> KOC_RESM
  98. %token <intv> KOC_SDEF
  99. %token <intv> KOC_SET
  100. %token <intv> KOC_WDEF
  101. %token <intv> KOC_CHSET
  102. %token <intv> KOC_CHDEF
  103. %token <intv> KOC_CHUSE
  104. %token <intv> KOC_opcode
  105.  
  106. %token <longv> CONSTANT
  107. %token EOL
  108. %token KEOP_AND
  109. %token KEOP_DEFINED
  110. %token KEOP_EQ
  111. %token KEOP_GE
  112. %token KEOP_GT
  113. %token KEOP_HIGH
  114. %token KEOP_LE
  115. %token KEOP_LOW
  116. %token KEOP_LT
  117. %token KEOP_MOD
  118. %token KEOP_MUN
  119. %token KEOP_NE
  120. %token KEOP_NOT
  121. %token KEOP_OR
  122. %token KEOP_SHL
  123. %token KEOP_SHR
  124. %token KEOP_XOR
  125. %token KEOP_locctr
  126. %token <symb> LABEL
  127. %token <strng> STRING
  128. %token <symb> SYMBOL
  129.  
  130. %token KTK_invalid
  131.  
  132. %right    KEOP_HIGH KEOP_LOW
  133. %left    KEOP_OR KEOP_XOR
  134. %left    KEOP_AND
  135. %right    KEOP_NOT
  136. %nonassoc    KEOP_GT KEOP_GE KEOP_LE KEOP_LT KEOP_NE KEOP_EQ
  137. %left    '+' '-'
  138. %left    '*' '/' KEOP_MOD KEOP_SHL KEOP_SHR
  139. %right    KEOP_MUN
  140.  
  141.  
  142. %type <intv> expr exprlist stringlist
  143.  
  144. %start file
  145.  
  146. %%
  147.  
  148. file    :    file allline
  149.     |    allline
  150.     ;
  151.  
  152. allline    :     line EOL
  153.             {
  154.                 clrexpr();
  155.             }
  156.     |    EOL
  157.     |    error EOL
  158.             {
  159.                 clrexpr();
  160.                 yyerrok;
  161.             }
  162.     ;
  163.  
  164. line    :    LABEL KOC_END 
  165.             {
  166.                 endsymbol = $1;
  167.                 nextreadact = Nra_end;
  168.             }
  169.     |          KOC_END 
  170.             {
  171.                 nextreadact = Nra_end;
  172.             }
  173.     |    KOC_INCLUDE STRING
  174.             {
  175.         if(nextfstk >= FILESTKDPTH)
  176.         {
  177.             fraerror("include file nesting limit exceeded");
  178.         }
  179.         else
  180.         {
  181.             infilestk[nextfstk].fnm = savestring($2,strlen($2));
  182.             if( (infilestk[nextfstk].fpt = fopen($2,"r"))
  183.                 ==(FILE *)NULL )
  184.             {
  185.                 fraerror("cannot open include file");
  186.             }
  187.             else
  188.             {
  189.                 nextreadact = Nra_new;
  190.             }
  191.         }
  192.             }
  193.     |    LABEL KOC_EQU expr 
  194.             {
  195.                 if($1 -> seg == SSG_UNDEF)
  196.                 {
  197.                     pevalexpr(0, $3);
  198.                     if(evalr[0].seg == SSG_ABS)
  199.                     {
  200.                         $1 -> seg = SSG_EQU;
  201.                         $1 -> value = evalr[0].value;
  202.                         prtequvalue("C: 0x%lx\n",
  203.                             evalr[0].value);
  204.                     }
  205.                     else
  206.                     {
  207.                         fraerror(
  208.                     "noncomputable expression for EQU");
  209.                     }
  210.                 }
  211.                 else
  212.                 {
  213.                     fraerror(
  214.                 "cannot change symbol value with EQU");
  215.                 }
  216.             }
  217.     |    LABEL KOC_SET expr 
  218.             {
  219.                 if($1 -> seg == SSG_UNDEF
  220.                    || $1 -> seg == SSG_SET)
  221.                 {
  222.                     pevalexpr(0, $3);
  223.                     if(evalr[0].seg == SSG_ABS)
  224.                     {
  225.                         $1 -> seg = SSG_SET;
  226.                         $1 -> value = evalr[0].value;
  227.                         prtequvalue("C: 0x%lx\n",
  228.                             evalr[0].value);
  229.                     }
  230.                     else
  231.                     {
  232.                         fraerror(
  233.                     "noncomputable expression for SET");
  234.                     }
  235.                 }
  236.                 else
  237.                 {
  238.                     fraerror(
  239.                 "cannot change symbol value with SET");
  240.                 }
  241.             }
  242.     |    KOC_IF expr 
  243.             {
  244.         if((++ifstkpt) < IFSTKDEPTH)
  245.         {
  246.             pevalexpr(0, $2);
  247.             if(evalr[0].seg == SSG_ABS)
  248.             {
  249.                 if(evalr[0].value != 0)
  250.                 {
  251.                     elseifstk[ifstkpt] = If_Skip;
  252.                     endifstk[ifstkpt] = If_Active;
  253.                 }
  254.                 else
  255.                 {
  256.                     fraifskip = TRUE;
  257.                     elseifstk[ifstkpt] = If_Active;
  258.                     endifstk[ifstkpt] = If_Active;
  259.                 }
  260.             }
  261.             else
  262.             {
  263.                 fraifskip = TRUE;
  264.                 elseifstk[ifstkpt] = If_Active;
  265.                 endifstk[ifstkpt] = If_Active;
  266.             }
  267.         }
  268.         else
  269.         {
  270.             fraerror("IF stack overflow");
  271.         }
  272.             }
  273.                         
  274.     |    KOC_IF 
  275.             {
  276.         if(fraifskip) 
  277.         {
  278.             if((++ifstkpt) < IFSTKDEPTH)
  279.             {
  280.                     elseifstk[ifstkpt] = If_Skip;
  281.                     endifstk[ifstkpt] = If_Skip;
  282.             }
  283.             else
  284.             {
  285.                 fraerror("IF stack overflow");
  286.             }
  287.         }
  288.         else
  289.         {
  290.             yyerror("syntax error");
  291.             YYERROR;
  292.         }
  293.                 }
  294.                         
  295.     |    KOC_ELSE 
  296.             {
  297.                 switch(elseifstk[ifstkpt])
  298.                 {
  299.                 case If_Active:
  300.                     fraifskip = FALSE;
  301.                     break;
  302.                 
  303.                 case If_Skip:
  304.                     fraifskip = TRUE;
  305.                     break;
  306.                 
  307.                 case If_Err:
  308.                     fraerror("ELSE with no matching if");
  309.                     break;
  310.                 }
  311.             }
  312.  
  313.     |    KOC_ENDI 
  314.             {
  315.                 switch(endifstk[ifstkpt])
  316.                 {
  317.                 case If_Active:
  318.                     fraifskip = FALSE;
  319.                     ifstkpt--;
  320.                     break;
  321.                 
  322.                 case If_Skip:
  323.                     fraifskip = TRUE;
  324.                     ifstkpt--;
  325.                     break;
  326.                 
  327.                 case If_Err:
  328.                     fraerror("ENDI with no matching if");
  329.                     break;
  330.                 }
  331.             }
  332.     |    LABEL KOC_ORG expr 
  333.             {
  334.                 pevalexpr(0, $3);
  335.                 if(evalr[0].seg == SSG_ABS)
  336.                 {
  337.                     locctr = labelloc = evalr[0].value;
  338.                     if($1 -> seg == SSG_UNDEF)
  339.                     {
  340.                         $1 -> seg = SSG_ABS;
  341.                         $1 -> value = labelloc;
  342.                     }
  343.                     else
  344.                         fraerror(
  345.                         "multiple definition of label");
  346.                     prtequvalue("C: 0x%lx\n",
  347.                         evalr[0].value);
  348.                 }
  349.                 else
  350.                 {
  351.                     fraerror(
  352.                      "noncomputable expression for ORG");
  353.                 }
  354.             }
  355.     |          KOC_ORG expr 
  356.             {
  357.                 pevalexpr(0, $2);
  358.                 if(evalr[0].seg == SSG_ABS)
  359.                 {
  360.                     locctr = labelloc = evalr[0].value;
  361.                     prtequvalue("C: 0x%lx\n",
  362.                         evalr[0].value);
  363.                 }
  364.                 else
  365.                 {
  366.                     fraerror(
  367.                      "noncomputable expression for ORG");
  368.                 }
  369.             }
  370.     |    LABEL KOC_CHSET
  371.             {
  372.                 if($1 -> seg == SSG_UNDEF)
  373.                 {
  374.                     $1 -> seg = SSG_EQU;
  375.                     if( ($1->value = chtcreate()) <= 0)
  376.                     {
  377.         fraerror( "cannot create character translation table");
  378.                     }
  379.                     prtequvalue("C: 0x%lx\n", $1 -> value);
  380.                 }
  381.                 else
  382.                 {
  383.             fraerror( "multiple definition of label");
  384.                 }
  385.             }
  386.     |        KOC_CHUSE
  387.             {
  388.                 chtcpoint = (int *) NULL;
  389.                 prtequvalue("C: 0x%lx\n", 0L);
  390.             }
  391.     |        KOC_CHUSE expr
  392.             {
  393.                 pevalexpr(0, $2);
  394.                 if( evalr[0].seg == SSG_ABS)
  395.                 {
  396.                     if( evalr[0].value == 0)
  397.                     {
  398.                         chtcpoint = (int *)NULL;
  399.                         prtequvalue("C: 0x%lx\n", 0L);
  400.                     }
  401.                     else if(evalr[0].value < chtnxalph)
  402.                     {
  403.                 chtcpoint = chtatab[evalr[0].value];
  404.                 prtequvalue("C: 0x%lx\n", evalr[0].value);
  405.                     }
  406.                     else
  407.                     {
  408.             fraerror("nonexistent character translation table");
  409.                     }
  410.                 }
  411.                 else
  412.                 {
  413.                     fraerror("noncomputable expression");
  414.                 }
  415.             }
  416.     |        KOC_CHDEF STRING ',' exprlist
  417.             {
  418.         int findrv, numret, *charaddr;
  419.         char *sourcestr = $2, *before;
  420.  
  421.         if(chtnpoint != (int *)NULL)
  422.         {
  423.             for(satsub = 0; satsub < $4; satsub++)
  424.             {
  425.                 before = sourcestr;
  426.  
  427.                 pevalexpr(0, exprlist[satsub]);
  428.                 findrv = chtcfind(chtnpoint, &sourcestr,
  429.                         &charaddr, &numret);
  430.                 if(findrv == CF_END)
  431.                 {
  432.             fraerror("more expressions than characters");
  433.                     break;
  434.                 }
  435.  
  436.                 if(evalr[0].seg == SSG_ABS)
  437.                 {
  438.                     switch(findrv)
  439.                     {
  440.                     case CF_UNDEF:
  441.                         {
  442.                 if(evalr[0].value < 0 ||
  443.                     evalr[0].value > 255)
  444.                 {
  445.             frawarn("character translation value truncated");
  446.                 }
  447.                 *charaddr = evalr[0].value & 0xff;
  448.                 prtequvalue("C: 0x%lx\n", evalr[0].value);
  449.                         }
  450.                         break;
  451.  
  452.                     case CF_INVALID:
  453.                     case CF_NUMBER:
  454.                 fracherror("invalid character to define", 
  455.                     before, sourcestr);
  456.                         break;
  457.  
  458.                     case CF_CHAR:
  459.                 fracherror("character already defined", 
  460.                     before, sourcestr);
  461.                         break;
  462.                     }
  463.                 }
  464.                 else
  465.                 {
  466.                     fraerror("noncomputable expression");
  467.                 }
  468.             }
  469.  
  470.             if( *sourcestr != '\0')
  471.             {
  472.                 fraerror("more characters than expressions");
  473.             }
  474.         }
  475.         else
  476.         {
  477.             fraerror("no CHARSET statement active");
  478.         }
  479.             
  480.             }
  481.     |    LABEL 
  482.             {
  483.             if($1 -> seg == SSG_UNDEF)
  484.             {
  485.                 $1 -> seg = SSG_ABS;
  486.                 $1 -> value = labelloc;
  487.                 prtequvalue("C: 0x%lx\n", labelloc);
  488.  
  489.             }
  490.             else
  491.                 fraerror(
  492.                 "multiple definition of label");
  493.             }
  494.     |    labeledline
  495.     ;
  496.  
  497. labeledline :    LABEL genline
  498.             {
  499.             if($1 -> seg == SSG_UNDEF)
  500.             {
  501.                 $1 -> seg = SSG_ABS;
  502.                 $1 -> value = labelloc;
  503.             }
  504.             else
  505.                 fraerror(
  506.                 "multiple definition of label");
  507.             labelloc = locctr;
  508.             }
  509.                 
  510.     |    genline
  511.             {
  512.                 labelloc = locctr;
  513.             }
  514.     ;
  515.  
  516. genline    :    KOC_BDEF    exprlist 
  517.             {
  518.                 genlocrec(currseg, labelloc);
  519.                 for( satsub = 0; satsub < $2; satsub++)
  520.                 {
  521.                     pevalexpr(1, exprlist[satsub]);
  522.                     locctr += geninstr(genbdef);
  523.                 }
  524.             }
  525.     |    KOC_SDEF stringlist 
  526.             {
  527.                 genlocrec(currseg, labelloc);
  528.                 for(satsub = 0; satsub < $2; satsub++)
  529.                 {
  530.                     locctr += genstring(stringlist[satsub]);
  531.                 }
  532.             }
  533.     |    KOC_WDEF exprlist 
  534.             {
  535.                 genlocrec(currseg, labelloc);
  536.                 for( satsub = 0; satsub < $2; satsub++)
  537.                 {
  538.                     pevalexpr(1, exprlist[satsub]);
  539.                     locctr += geninstr(genwdef);
  540.                 }
  541.             }    
  542.     |    KOC_RESM expr 
  543.             {
  544.                 pevalexpr(0, $2);
  545.                 if(evalr[0].seg == SSG_ABS)
  546.                 {
  547.                     locctr = labelloc + evalr[0].value;
  548.                     prtequvalue("C: 0x%lx\n", labelloc);
  549.                 }
  550.                 else
  551.                 {
  552.                     fraerror(
  553.                  "noncomputable result for RMB expression");
  554.                 }
  555.             }
  556.     ;
  557.  
  558. exprlist :    exprlist ',' expr
  559.             {
  560.                 exprlist[nextexprs ++ ] = $3;
  561.                 $$ = nextexprs;
  562.             }
  563.     |    expr
  564.             {
  565.                 nextexprs = 0;
  566.                 exprlist[nextexprs ++ ] = $1;
  567.                 $$ = nextexprs;
  568.             }
  569.     ;
  570.  
  571. stringlist :    stringlist ',' STRING
  572.             {
  573.                 stringlist[nextstrs ++ ] = $3;
  574.                 $$ = nextstrs;
  575.             }
  576.     |    STRING
  577.             {
  578.                 nextstrs = 0;
  579.                 stringlist[nextstrs ++ ] = $1;
  580.                 $$ = nextstrs;
  581.             }
  582.     ;
  583.  
  584.  
  585. genline : KOC_opcode 
  586.             {
  587.         genlocrec(currseg, labelloc);
  588.         locctr += geninstr(findgen($1, ST_INH,  0));
  589.             }
  590.     ;
  591. genline : KOC_opcode  expr
  592.             {
  593.         genlocrec(currseg, labelloc);
  594.         pevalexpr(1,$2);
  595.         operselbits = 0;
  596.         if(evalr[1].seg == SSG_ABS)
  597.         {
  598.             if(evalr[1].value == 0)
  599.             {
  600.                 operselbits |= DSTA;
  601.             }
  602.             else if(evalr[1].value == 1)
  603.             {
  604.                 operselbits |= DSTB;
  605.             }
  606.         }    
  607.         locctr += geninstr(findgen($1, ST_EXPR, operselbits));
  608.             }
  609.     ;
  610. genline : KOC_opcode  expr ',' expr
  611.             {
  612.         genlocrec(currseg, labelloc);
  613.         pevalexpr(1,$2);
  614.         pevalexpr(2,$4);
  615.         operselbits = 0;
  616.         if(evalr[1].seg == SSG_ABS)
  617.         {
  618.             if(evalr[1].value == 0)
  619.             {
  620.                 operselbits |= SRCA;
  621.             }
  622.             else if(evalr[1].value == 1)
  623.             {
  624.                 operselbits |= SRCB;
  625.             }
  626.         }    
  627.         if(evalr[2].seg == SSG_ABS)
  628.         {
  629.             if(evalr[2].value == 0)
  630.             {
  631.                 operselbits |= DSTA;
  632.             }
  633.             else if(evalr[2].value == 1)
  634.             {
  635.                 operselbits |= DSTB;
  636.             }
  637.         }    
  638.         locctr += geninstr(findgen($1, ST_EXPR2, operselbits));
  639.             }
  640.     ;
  641. genline : KOC_opcode  expr ',' expr ',' expr
  642.             {
  643.         genlocrec(currseg, labelloc);
  644.         pevalexpr(1,$2);
  645.         pevalexpr(2,$4);
  646.         pevalexpr(3,$6);
  647.         operselbits = 0;
  648.         if(evalr[1].seg == SSG_ABS)
  649.         {
  650.             if(evalr[1].value == 0)
  651.             {
  652.                 operselbits |= SRCA;
  653.             }
  654.             else if(evalr[1].value == 1)
  655.             {
  656.                 operselbits |= SRCB;
  657.             }
  658.         }    
  659.         if(evalr[2].seg == SSG_ABS)
  660.         {
  661.             if(evalr[2].value == 0)
  662.             {
  663.                 operselbits |= DSTA;
  664.             }
  665.             else if(evalr[2].value == 1)
  666.             {
  667.                 operselbits |= DSTB;
  668.             }
  669.         }    
  670.         locctr += geninstr(findgen($1, ST_EXPR3, operselbits));
  671.             }
  672.     ;
  673. genline : KOC_opcode  '#' expr ',' expr
  674.             {
  675.         genlocrec(currseg, labelloc);
  676.         pevalexpr(1,$3);
  677.         pevalexpr(2,$5);
  678.         operselbits = 0;
  679.         if(evalr[2].seg == SSG_ABS)
  680.         {
  681.             if(evalr[2].value == 0)
  682.             {
  683.                 operselbits |= DSTA;
  684.             }
  685.             else if(evalr[2].value == 1)
  686.             {
  687.                 operselbits |= DSTB;
  688.             }
  689.         }    
  690.         locctr += geninstr(findgen($1, ST_IEXPR2, operselbits));
  691.             }
  692.     ;
  693. genline : KOC_opcode  '#' expr ',' expr ',' expr
  694.             {
  695.         genlocrec(currseg, labelloc);
  696.         pevalexpr(1,$3);
  697.         pevalexpr(2,$5);
  698.         pevalexpr(3,$7);
  699.         operselbits = 0;
  700.         if(evalr[2].seg == SSG_ABS)
  701.         {
  702.             if(evalr[2].value == 0)
  703.             {
  704.                 operselbits |= DSTA;
  705.             }
  706.             else if(evalr[2].value == 1)
  707.             {
  708.                 operselbits |= DSTB;
  709.             }
  710.         }    
  711.         locctr += geninstr(findgen($1, ST_IEXPR3, operselbits));
  712.             }
  713.     ;
  714. genline : KOC_opcode  expr '(' REG ')'
  715.             {
  716.         genlocrec(currseg, labelloc);
  717.         pevalexpr(1,$2);
  718.         operselbits = 0;
  719.         if($4 == 0)
  720.         {
  721.             operselbits |= SRCA;
  722.         }
  723.         else if($4 == 1)
  724.         {
  725.             operselbits |= SRCB;
  726.         }
  727.         locctr += geninstr(findgen($1, ST_INDEX,  operselbits));
  728.             }
  729.     ;
  730. genline : KOC_opcode  '#' expr '(' REG ')' ',' expr
  731.             {
  732.         genlocrec(currseg, labelloc);
  733.         pevalexpr(1,$3);
  734.         pevalexpr(2,$8);
  735.         operselbits = 0;
  736.         if($5 == 0)
  737.         {
  738.             operselbits |= SRCA;
  739.         }
  740.         else if($5 == 1)
  741.         {
  742.             operselbits |= SRCB;
  743.         }
  744.         locctr += geninstr(findgen($1, ST_IMMIND,  operselbits));
  745.             }
  746.     ;
  747. genline : KOC_opcode  '[' expr ']'
  748.             {
  749.         genlocrec(currseg, labelloc);
  750.         pevalexpr(1,$3);
  751.         locctr += geninstr(findgen($1, ST_RINDIR,  0));
  752.             }
  753.     ;
  754. genline : KOC_opcode   STATUS
  755.             {
  756.         genlocrec(currseg, labelloc);
  757.         locctr += geninstr(findgen($1, ST_STATUS,  0));
  758.             }
  759.     ;
  760. expr    :    '+' expr %prec KEOP_MUN
  761.             {
  762.                 $$ = $2;
  763.             }
  764.     |    '-' expr %prec KEOP_MUN
  765.             {
  766.                 $$ = exprnode(PCCASE_UN,$2,IFC_NEG,0,0L,
  767.                     SYMNULL);
  768.             }
  769.     |    KEOP_NOT expr
  770.             {
  771.                 $$ = exprnode(PCCASE_UN,$2,IFC_NOT,0,0L,
  772.                     SYMNULL);
  773.             }
  774.     |    KEOP_HIGH expr
  775.             {
  776.                 $$ = exprnode(PCCASE_UN,$2,IFC_HIGH,0,0L,
  777.                     SYMNULL);
  778.             }
  779.     |    KEOP_LOW expr
  780.             {
  781.                 $$ = exprnode(PCCASE_UN,$2,IFC_LOW,0,0L,
  782.                     SYMNULL);
  783.             }
  784.     |    expr '*' expr
  785.             {
  786.                 $$ = exprnode(PCCASE_BIN,$1,IFC_MUL,$3,0L,
  787.                     SYMNULL);
  788.             }
  789.     |    expr '/' expr
  790.             {
  791.                 $$ = exprnode(PCCASE_BIN,$1,IFC_DIV,$3,0L,
  792.                     SYMNULL);
  793.             }
  794.     |    expr '+' expr
  795.             {
  796.                 $$ = exprnode(PCCASE_BIN,$1,IFC_ADD,$3,0L,
  797.                     SYMNULL);
  798.             }
  799.     |    expr '-' expr
  800.             {
  801.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SUB,$3,0L,
  802.                     SYMNULL);
  803.             }
  804.     |    expr KEOP_MOD expr
  805.             {
  806.                 $$ = exprnode(PCCASE_BIN,$1,IFC_MOD,$3,0L,
  807.                     SYMNULL);
  808.             }
  809.     |    expr KEOP_SHL expr
  810.             {
  811.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SHL,$3,0L,
  812.                     SYMNULL);
  813.             }
  814.     |    expr KEOP_SHR expr
  815.             {
  816.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SHR,$3,0L,
  817.                     SYMNULL);
  818.             }
  819.     |    expr KEOP_GT expr
  820.             {
  821.                 $$ = exprnode(PCCASE_BIN,$1,IFC_GT,$3,0L,
  822.                     SYMNULL);
  823.             }
  824.     |    expr KEOP_GE expr
  825.             {
  826.                 $$ = exprnode(PCCASE_BIN,$1,IFC_GE,$3,0L,
  827.                     SYMNULL);
  828.             }
  829.     |    expr KEOP_LT expr
  830.             {
  831.                 $$ = exprnode(PCCASE_BIN,$1,IFC_LT,$3,0L,
  832.                     SYMNULL);
  833.             }
  834.     |    expr KEOP_LE expr
  835.             {
  836.                 $$ = exprnode(PCCASE_BIN,$1,IFC_LE,$3,0L,
  837.                     SYMNULL);
  838.             }
  839.     |    expr KEOP_NE expr
  840.             {
  841.                 $$ = exprnode(PCCASE_BIN,$1,IFC_NE,$3,0L,
  842.                     SYMNULL);
  843.             }
  844.     |    expr KEOP_EQ expr
  845.             {
  846.                 $$ = exprnode(PCCASE_BIN,$1,IFC_EQ,$3,0L,
  847.                     SYMNULL);
  848.             }
  849.     |    expr KEOP_AND expr
  850.             {
  851.                 $$ = exprnode(PCCASE_BIN,$1,IFC_AND,$3,0L,
  852.                     SYMNULL);
  853.             }
  854.     |    expr KEOP_OR expr
  855.             {
  856.                 $$ = exprnode(PCCASE_BIN,$1,IFC_OR,$3,0L,
  857.                     SYMNULL);
  858.             }
  859.     |    expr KEOP_XOR expr
  860.             {
  861.                 $$ = exprnode(PCCASE_BIN,$1,IFC_XOR,$3,0L,
  862.                     SYMNULL);
  863.             }
  864.     |    KEOP_DEFINED SYMBOL
  865.             {
  866.                 $$ = exprnode(PCCASE_DEF,0,IGP_DEFINED,0,0L,$2);
  867.             }
  868.     |    SYMBOL
  869.             {
  870.                 $$ = exprnode(PCCASE_SYMB,0,IFC_SYMB,0,0L,$1);
  871.             }
  872.     |    '*'
  873.             {
  874.                 $$ = exprnode(PCCASE_PROGC,0,IFC_PROGCTR,0,
  875.                     labelloc, SYMNULL);
  876.             }
  877.     |    CONSTANT
  878.             {
  879.                 $$ = exprnode(PCCASE_CONS,0,IGP_CONSTANT,0,$1,
  880.                     SYMNULL);
  881.             }
  882.     |    STRING
  883.             {
  884.                 char *sourcestr = $1;
  885.                 long accval = 0;
  886.  
  887.                 if(strlen($1) > 0)
  888.                 {
  889.                     accval = chtran(&sourcestr);
  890.                     if(*sourcestr != '\0')
  891.                     {
  892.                         accval = (accval << 8) +
  893.                             chtran(&sourcestr);
  894.                     }
  895.  
  896.                     if( *sourcestr != '\0')
  897.                     {
  898.     frawarn("string constant in expression more than 2 characters long");
  899.                     }
  900.                 }
  901.                 $$ = exprnode(PCCASE_CONS, 0, IGP_CONSTANT, 0,
  902.                     accval, SYMNULL);
  903.             }
  904.     |    '(' expr ')'
  905.             {
  906.                 $$ = $2;
  907.             }
  908.     ;
  909.  
  910.  
  911. expr    :    REG
  912.         {
  913.     $$ = exprnode(PCCASE_CONS,0,IGP_CONSTANT,0,(long)$1,SYMNULL);
  914.         }
  915.     ;
  916.  
  917. %%
  918.  
  919. lexintercept()
  920. /*
  921.     description    intercept the call to yylex (the lexical analyzer)
  922.             and filter out all unnecessary tokens when skipping
  923.             the input between a failed IF and its matching ENDI or
  924.             ELSE
  925.     globals     fraifskip    the enable flag
  926. */
  927. {
  928. #undef yylex
  929.  
  930.     int rv;
  931.  
  932.     if(fraifskip)
  933.     {
  934.         for(;;)
  935.         {
  936.  
  937.             switch(rv = yylex())
  938.  
  939.             {
  940.             case 0:
  941.             case KOC_END:
  942.             case KOC_IF:
  943.             case KOC_ELSE:
  944.             case KOC_ENDI:
  945.             case EOL:
  946.                 return rv;
  947.             default:
  948.                 break;
  949.             }
  950.         }
  951.     }
  952.     else
  953.         return yylex();
  954. #define yylex lexintercept
  955. }
  956.  
  957.  
  958.  
  959. setreserved()
  960. {
  961.  
  962.     reservedsym("and", KEOP_AND, 0);
  963.     reservedsym("defined", KEOP_DEFINED,0);
  964.     reservedsym("eq", KEOP_EQ, 0);
  965.     reservedsym("ge", KEOP_GE, 0);
  966.     reservedsym("gt", KEOP_GT, 0);
  967.     reservedsym("high", KEOP_HIGH, 0);
  968.     reservedsym("le", KEOP_LE, 0);
  969.     reservedsym("low", KEOP_LOW, 0);
  970.     reservedsym("lt", KEOP_LT, 0);
  971.     reservedsym("mod", KEOP_MOD, 0);
  972.     reservedsym("ne", KEOP_NE, 0);
  973.     reservedsym("not", KEOP_NOT, 0);
  974.     reservedsym("or", KEOP_OR, 0);
  975.     reservedsym("shl", KEOP_SHL, 0);
  976.     reservedsym("shr", KEOP_SHR, 0);
  977.     reservedsym("xor", KEOP_XOR, 0);
  978.     reservedsym("AND", KEOP_AND, 0);
  979.     reservedsym("DEFINED", KEOP_DEFINED,0);
  980.     reservedsym("EQ", KEOP_EQ, 0);
  981.     reservedsym("GE", KEOP_GE, 0);
  982.     reservedsym("GT", KEOP_GT, 0);
  983.     reservedsym("HIGH", KEOP_HIGH, 0);
  984.     reservedsym("LE", KEOP_LE, 0);
  985.     reservedsym("LOW", KEOP_LOW, 0);
  986.     reservedsym("LT", KEOP_LT, 0);
  987.     reservedsym("MOD", KEOP_MOD, 0);
  988.     reservedsym("NE", KEOP_NE, 0);
  989.     reservedsym("NOT", KEOP_NOT, 0);
  990.     reservedsym("OR", KEOP_OR, 0);
  991.     reservedsym("SHL", KEOP_SHL, 0);
  992.     reservedsym("SHR", KEOP_SHR, 0);
  993.     reservedsym("XOR", KEOP_XOR, 0);
  994.  
  995.     /* machine specific token definitions */
  996.     reservedsym("st", STATUS, 0);
  997.     reservedsym("a", REG, 0);
  998.     reservedsym("b", REG, 1);
  999.     reservedsym("ST", STATUS, 0);
  1000.     reservedsym("A", REG, 0);
  1001.     reservedsym("B", REG, 1);
  1002.  
  1003. }
  1004.  
  1005.  
  1006. cpumatch(str)
  1007.     char * str;
  1008. {
  1009.     return TRUE;
  1010. }
  1011.  
  1012. /*
  1013.     description    Opcode and Instruction generation tables
  1014.     usage        Unix, framework crossassembler
  1015.     history        September 25, 1987
  1016. */
  1017.  
  1018. #define NUMOPCODE 92
  1019. #define NUMSYNBLK 104
  1020. #define NUMDIFFOP 213
  1021.  
  1022. int gnumopcode = NUMOPCODE;
  1023.  
  1024. int ophashlnk[NUMOPCODE];
  1025.  
  1026. struct opsym optab[NUMOPCODE+1]
  1027.     = {
  1028.     {"invalid", KOC_opcode, 2, 0 },
  1029.     {"ADC", KOC_opcode, 2, 2 },
  1030.     {"ADD", KOC_opcode, 2, 4 },
  1031.     {"AND", KOC_opcode, 2, 6 },
  1032.     {"ANDP", KOC_opcode, 2, 8 },
  1033.     {"BR", KOC_opcode, 3, 10 },
  1034.     {"BTJO", KOC_opcode, 2, 13 },
  1035.     {"BTJOP", KOC_opcode, 2, 15 },
  1036.     {"BTJZ", KOC_opcode, 2, 17 },
  1037.     {"BTJZP", KOC_opcode, 2, 19 },
  1038.     {"BYTE", KOC_BDEF, 0, 0 },
  1039.     {"CALL", KOC_opcode, 3, 21 },
  1040.     {"CHARDEF", KOC_CHDEF, 0, 0 },
  1041.     {"CHARSET", KOC_CHSET, 0, 0 },
  1042.     {"CHARUSE", KOC_CHUSE, 0, 0 },
  1043.     {"CHD", KOC_CHDEF, 0, 0 },
  1044.     {"CLR", KOC_opcode, 1, 24 },
  1045.     {"CLRC", KOC_opcode, 1, 25 },
  1046.     {"CMP", KOC_opcode, 2, 26 },
  1047.     {"CMPA", KOC_opcode, 3, 28 },
  1048.     {"DAC", KOC_opcode, 2, 31 },
  1049.     {"DB", KOC_BDEF, 0, 0 },
  1050.     {"DEC", KOC_opcode, 1, 33 },
  1051.     {"DECD", KOC_opcode, 1, 34 },
  1052.     {"DINT", KOC_opcode, 1, 35 },
  1053.     {"DJNZ", KOC_opcode, 1, 36 },
  1054.     {"DSB", KOC_opcode, 2, 37 },
  1055.     {"DW", KOC_WDEF, 0, 0 },
  1056.     {"EINT", KOC_opcode, 1, 39 },
  1057.     {"ELSE", KOC_ELSE, 0, 0 },
  1058.     {"END", KOC_END, 0, 0 },
  1059.     {"ENDI", KOC_ENDI, 0, 0 },
  1060.     {"EQU", KOC_EQU, 0, 0 },
  1061.     {"FCB", KOC_BDEF, 0, 0 },
  1062.     {"FCC", KOC_SDEF, 0, 0 },
  1063.     {"FDB", KOC_WDEF, 0, 0 },
  1064.     {"IDLE", KOC_opcode, 1, 40 },
  1065.     {"IF", KOC_IF, 0, 0 },
  1066.     {"INC", KOC_opcode, 1, 41 },
  1067.     {"INCL", KOC_INCLUDE, 0, 0 },
  1068.     {"INCLUDE", KOC_INCLUDE, 0, 0 },
  1069.     {"INV", KOC_opcode, 1, 42 },
  1070.     {"JC", KOC_opcode, 1, 43 },
  1071.     {"JEQ", KOC_opcode, 1, 44 },
  1072.     {"JGE", KOC_opcode, 1, 45 },
  1073.     {"JGT", KOC_opcode, 1, 46 },
  1074.     {"JHS", KOC_opcode, 1, 47 },
  1075.     {"JL", KOC_opcode, 1, 48 },
  1076.     {"JLT", KOC_opcode, 1, 49 },
  1077.     {"JMP", KOC_opcode, 1, 50 },
  1078.     {"JN", KOC_opcode, 1, 51 },
  1079.     {"JNC", KOC_opcode, 1, 52 },
  1080.     {"JNE", KOC_opcode, 1, 53 },
  1081.     {"JNZ", KOC_opcode, 1, 54 },
  1082.     {"JP", KOC_opcode, 1, 55 },
  1083.     {"JPZ", KOC_opcode, 1, 56 },
  1084.     {"JZ", KOC_opcode, 1, 57 },
  1085.     {"LDA", KOC_opcode, 3, 58 },
  1086.     {"LDSP", KOC_opcode, 1, 61 },
  1087.     {"MOV", KOC_opcode, 2, 62 },
  1088.     {"MOVD", KOC_opcode, 3, 64 },
  1089.     {"MOVP", KOC_opcode, 2, 67 },
  1090.     {"MPY", KOC_opcode, 2, 69 },
  1091.     {"NOP", KOC_opcode, 1, 71 },
  1092.     {"OR", KOC_opcode, 2, 72 },
  1093.     {"ORG", KOC_ORG, 0, 0 },
  1094.     {"ORP", KOC_opcode, 2, 74 },
  1095.     {"POP", KOC_opcode, 2, 76 },
  1096.     {"PUSH", KOC_opcode, 2, 78 },
  1097.     {"RESERVE", KOC_RESM, 0, 0 },
  1098.     {"RETI", KOC_opcode, 1, 80 },
  1099.     {"RETS", KOC_opcode, 1, 81 },
  1100.     {"RL", KOC_opcode, 1, 82 },
  1101.     {"RLC", KOC_opcode, 1, 83 },
  1102.     {"RMB", KOC_RESM, 0, 0 },
  1103.     {"RR", KOC_opcode, 1, 84 },
  1104.     {"RRC", KOC_opcode, 1, 85 },
  1105.     {"SBB", KOC_opcode, 2, 86 },
  1106.     {"SET", KOC_SET, 0, 0 },
  1107.     {"SETC", KOC_opcode, 1, 88 },
  1108.     {"STA", KOC_opcode, 3, 89 },
  1109.     {"STRING", KOC_SDEF, 0, 0 },
  1110.     {"STSP", KOC_opcode, 1, 92 },
  1111.     {"SUB", KOC_opcode, 2, 93 },
  1112.     {"SWAP", KOC_opcode, 1, 95 },
  1113.     {"TRAP", KOC_opcode, 1, 96 },
  1114.     {"TSTA", KOC_opcode, 1, 97 },
  1115.     {"TSTB", KOC_opcode, 1, 98 },
  1116.     {"WORD", KOC_WDEF, 0, 0 },
  1117.     {"XCHB", KOC_opcode, 1, 99 },
  1118.     {"XOR", KOC_opcode, 2, 100 },
  1119.     {"XORP", KOC_opcode, 2, 102 },
  1120.     { "", 0, 0, 0 }};
  1121.  
  1122. struct opsynt ostab[NUMSYNBLK+1]
  1123.     = {
  1124. /* invalid 0 */ { 0, 1, 0 },
  1125. /* invalid 1 */ { 0xffff, 1, 1 },
  1126. /* ADC 2 */ { ST_EXPR2, 4, 2 },
  1127. /* ADC 3 */ { ST_IEXPR2, 3, 6 },
  1128. /* ADD 4 */ { ST_EXPR2, 4, 9 },
  1129. /* ADD 5 */ { ST_IEXPR2, 3, 13 },
  1130. /* AND 6 */ { ST_EXPR2, 4, 16 },
  1131. /* AND 7 */ { ST_IEXPR2, 3, 20 },
  1132. /* ANDP 8 */ { ST_EXPR2, 2, 23 },
  1133. /* ANDP 9 */ { ST_IEXPR2, 1, 25 },
  1134. /* BR 10 */ { ST_EXPR, 1, 26 },
  1135. /* BR 11 */ { ST_INDEX, 1, 27 },
  1136. /* BR 12 */ { ST_RINDIR, 1, 28 },
  1137. /* BTJO 13 */ { ST_EXPR3, 4, 29 },
  1138. /* BTJO 14 */ { ST_IEXPR3, 3, 33 },
  1139. /* BTJOP 15 */ { ST_EXPR3, 2, 36 },
  1140. /* BTJOP 16 */ { ST_IEXPR3, 1, 38 },
  1141. /* BTJZ 17 */ { ST_EXPR3, 4, 39 },
  1142. /* BTJZ 18 */ { ST_IEXPR3, 3, 43 },
  1143. /* BTJZP 19 */ { ST_EXPR3, 2, 46 },
  1144. /* BTJZP 20 */ { ST_IEXPR3, 1, 48 },
  1145. /* CALL 21 */ { ST_EXPR, 1, 49 },
  1146. /* CALL 22 */ { ST_INDEX, 1, 50 },
  1147. /* CALL 23 */ { ST_RINDIR, 1, 51 },
  1148. /* CLR 24 */ { ST_EXPR, 3, 52 },
  1149. /* CLRC 25 */ { ST_INH, 1, 55 },
  1150. /* CMP 26 */ { ST_EXPR2, 4, 56 },
  1151. /* CMP 27 */ { ST_IEXPR2, 3, 60 },
  1152. /* CMPA 28 */ { ST_EXPR, 1, 63 },
  1153. /* CMPA 29 */ { ST_INDEX, 1, 64 },
  1154. /* CMPA 30 */ { ST_RINDIR, 1, 65 },
  1155. /* DAC 31 */ { ST_EXPR2, 4, 66 },
  1156. /* DAC 32 */ { ST_IEXPR2, 3, 70 },
  1157. /* DEC 33 */ { ST_EXPR, 3, 73 },
  1158. /* DECD 34 */ { ST_EXPR, 3, 76 },
  1159. /* DINT 35 */ { ST_INH, 1, 79 },
  1160. /* DJNZ 36 */ { ST_EXPR2, 3, 80 },
  1161. /* DSB 37 */ { ST_EXPR2, 4, 83 },
  1162. /* DSB 38 */ { ST_IEXPR2, 3, 87 },
  1163. /* EINT 39 */ { ST_INH, 1, 90 },
  1164. /* IDLE 40 */ { ST_INH, 1, 91 },
  1165. /* INC 41 */ { ST_EXPR, 3, 92 },
  1166. /* INV 42 */ { ST_EXPR, 3, 95 },
  1167. /* JC 43 */ { ST_EXPR, 1, 98 },
  1168. /* JEQ 44 */ { ST_EXPR, 1, 99 },
  1169. /* JGE 45 */ { ST_EXPR, 1, 100 },
  1170. /* JGT 46 */ { ST_EXPR, 1, 101 },
  1171. /* JHS 47 */ { ST_EXPR, 1, 102 },
  1172. /* JL 48 */ { ST_EXPR, 1, 103 },
  1173. /* JLT 49 */ { ST_EXPR, 1, 104 },
  1174. /* JMP 50 */ { ST_EXPR, 1, 105 },
  1175. /* JN 51 */ { ST_EXPR, 1, 106 },
  1176. /* JNC 52 */ { ST_EXPR, 1, 107 },
  1177. /* JNE 53 */ { ST_EXPR, 1, 108 },
  1178. /* JNZ 54 */ { ST_EXPR, 1, 109 },
  1179. /* JP 55 */ { ST_EXPR, 1, 110 },
  1180. /* JPZ 56 */ { ST_EXPR, 1, 111 },
  1181. /* JZ 57 */ { ST_EXPR, 1, 112 },
  1182. /* LDA 58 */ { ST_EXPR, 1, 113 },
  1183. /* LDA 59 */ { ST_INDEX, 1, 114 },
  1184. /* LDA 60 */ { ST_RINDIR, 1, 115 },
  1185. /* LDSP 61 */ { ST_INH, 1, 116 },
  1186. /* MOV 62 */ { ST_EXPR2, 7, 117 },
  1187. /* MOV 63 */ { ST_IEXPR2, 3, 124 },
  1188. /* MOVD 64 */ { ST_EXPR2, 1, 127 },
  1189. /* MOVD 65 */ { ST_IEXPR2, 1, 128 },
  1190. /* MOVD 66 */ { ST_IMMIND, 1, 129 },
  1191. /* MOVP 67 */ { ST_EXPR2, 4, 130 },
  1192. /* MOVP 68 */ { ST_IEXPR2, 1, 134 },
  1193. /* MPY 69 */ { ST_EXPR2, 4, 135 },
  1194. /* MPY 70 */ { ST_IEXPR2, 3, 139 },
  1195. /* NOP 71 */ { ST_INH, 1, 142 },
  1196. /* OR 72 */ { ST_EXPR2, 4, 143 },
  1197. /* OR 73 */ { ST_IEXPR2, 3, 147 },
  1198. /* ORP 74 */ { ST_EXPR2, 2, 150 },
  1199. /* ORP 75 */ { ST_IEXPR2, 1, 152 },
  1200. /* POP 76 */ { ST_EXPR, 3, 153 },
  1201. /* POP 77 */ { ST_STATUS, 1, 156 },
  1202. /* PUSH 78 */ { ST_EXPR, 3, 157 },
  1203. /* PUSH 79 */ { ST_STATUS, 1, 160 },
  1204. /* RETI 80 */ { ST_INH, 1, 161 },
  1205. /* RETS 81 */ { ST_INH, 1, 162 },
  1206. /* RL 82 */ { ST_EXPR, 3, 163 },
  1207. /* RLC 83 */ { ST_EXPR, 3, 166 },
  1208. /* RR 84 */ { ST_EXPR, 3, 169 },
  1209. /* RRC 85 */ { ST_EXPR, 3, 172 },
  1210. /* SBB 86 */ { ST_EXPR2, 4, 175 },
  1211. /* SBB 87 */ { ST_IEXPR2, 3, 179 },
  1212. /* SETC 88 */ { ST_INH, 1, 182 },
  1213. /* STA 89 */ { ST_EXPR, 1, 183 },
  1214. /* STA 90 */ { ST_INDEX, 1, 184 },
  1215. /* STA 91 */ { ST_RINDIR, 1, 185 },
  1216. /* STSP 92 */ { ST_INH, 1, 186 },
  1217. /* SUB 93 */ { ST_EXPR2, 4, 187 },
  1218. /* SUB 94 */ { ST_IEXPR2, 3, 191 },
  1219. /* SWAP 95 */ { ST_EXPR, 3, 194 },
  1220. /* TRAP 96 */ { ST_EXPR, 1, 197 },
  1221. /* TSTA 97 */ { ST_INH, 1, 198 },
  1222. /* TSTB 98 */ { ST_INH, 1, 199 },
  1223. /* XCHB 99 */ { ST_EXPR, 3, 200 },
  1224. /* XOR 100 */ { ST_EXPR2, 4, 203 },
  1225. /* XOR 101 */ { ST_IEXPR2, 3, 207 },
  1226. /* XORP 102 */ { ST_EXPR2, 2, 210 },
  1227. /* XORP 103 */ { ST_IEXPR2, 1, 212 },
  1228.     { 0, 0, 0 } };
  1229.  
  1230. struct igel igtab[NUMDIFFOP+1]
  1231.     = {
  1232. /* invalid 0 */   { 0 , 0, 
  1233.         "[Xnullentry" },
  1234. /* invalid 1 */   { 0 , 0, 
  1235.         "[Xinvalid opcode" },
  1236. /* ADC 2 */   { SRCMASK|DSTMASK , SRCB|DSTA, 
  1237.         "69;" },
  1238. /* ADC 3 */   { DSTMASK , DSTA, 
  1239.         "19;[1=].8I;" },
  1240. /* ADC 4 */   { DSTMASK , DSTB, 
  1241.         "39;[1=].8I;" },
  1242. /* ADC 5 */   { 0 , 0, 
  1243.         "49;[1=].8I;[2=].8I;" },
  1244. /* ADC 6 */   { DSTMASK , DSTA, 
  1245.         "29;[1=];" },
  1246. /* ADC 7 */   { DSTMASK , DSTB, 
  1247.         "59;[1=];" },
  1248. /* ADC 8 */   { 0 , 0, 
  1249.         "79;[1=];[2=].8I;" },
  1250. /* ADD 9 */   { SRCMASK|DSTMASK , SRCB|DSTA, 
  1251.         "68;" },
  1252. /* ADD 10 */   { DSTMASK , DSTA, 
  1253.         "18;[1=].8I;" },
  1254. /* ADD 11 */   { DSTMASK , DSTB, 
  1255.         "38;[1=].8I;" },
  1256. /* ADD 12 */   { 0 , 0, 
  1257.         "48;[1=].8I;[2=].8I;" },
  1258. /* ADD 13 */   { DSTMASK , DSTA, 
  1259.         "28;[1=];" },
  1260. /* ADD 14 */   { DSTMASK , DSTB, 
  1261.         "58;[1=];" },
  1262. /* ADD 15 */   { 0 , 0, 
  1263.         "78;[1=];[2=].8I;" },
  1264. /* AND 16 */   { SRCMASK|DSTMASK , SRCB|DSTA, 
  1265.         "63;" },
  1266. /* AND 17 */   { DSTMASK , DSTA, 
  1267.         "13;[1=].8I;" },
  1268. /* AND 18 */   { DSTMASK , DSTB, 
  1269.         "33;[1=].8I;" },
  1270. /* AND 19 */   { 0 , 0, 
  1271.         "43;[1=].8I;[2=].8I;" },
  1272. /* AND 20 */   { DSTMASK , DSTA, 
  1273.         "23;[1=];" },
  1274. /* AND 21 */   { DSTMASK , DSTB, 
  1275.         "53;[1=];" },
  1276. /* AND 22 */   { 0 , 0, 
  1277.         "73;[1=];[2=].8I;" },
  1278. /* ANDP 23 */   { SRCMASK , SRCA, 
  1279.         "83;[2=].100-.8I;" },
  1280. /* ANDP 24 */   { SRCMASK , SRCB, 
  1281.         "93;[2=].100-.8I;" },
  1282. /* ANDP 25 */   { 0 , 0, 
  1283.         "a3;[1=];[2=].100-.8I;" },
  1284. /* BR 26 */   { 0 , 0, 
  1285.         "8c;[1=]x" },
  1286. /* BR 27 */   { SRCMASK , SRCB, 
  1287.         "ac;[1=]x" },
  1288. /* BR 28 */   { 0 , 0, 
  1289.         "9c;[1=].8I;" },
  1290. /* BTJO 29 */   { SRCMASK|DSTMASK , SRCB|DSTA, 
  1291.         "66;[3=].Q.1+-r" },
  1292. /* BTJO 30 */   { DSTMASK , DSTA, 
  1293.         "16;[1=].8I;[3=].Q.1+-r" },
  1294. /* BTJO 31 */   { DSTMASK , DSTB, 
  1295.         "36;[1=].8I;[3=].Q.1+-r" },
  1296. /* BTJO 32 */   { 0 , 0, 
  1297.         "46;[1=].8I;[2=].8I;[3=].Q.1+-r" },
  1298. /* BTJO 33 */   { DSTMASK , DSTA, 
  1299.         "26;[1=];[3=].Q.1+-r" },
  1300. /* BTJO 34 */   { DSTMASK , DSTB, 
  1301.         "56;[1=];[3=].Q.1+-r" },
  1302. /* BTJO 35 */   { 0 , 0, 
  1303.         "76;[1=];[2=].8I;[3=].Q.1+-r" },
  1304. /* BTJOP 36 */   { SRCMASK , SRCA, 
  1305.         "86;[2=].100-.8I;[3=].Q.1+-r" },
  1306. /* BTJOP 37 */   { SRCMASK , SRCB, 
  1307.         "96;[2=].100-.8I;[3=].Q.1+-r" },
  1308. /* BTJOP 38 */   { 0 , 0, 
  1309.         "a6;[1=];[2=].100-.8I;[3=].Q.1+-r" },
  1310. /* BTJZ 39 */   { SRCMASK|DSTMASK , SRCB|DSTA, 
  1311.         "67;[3=].Q.1+-r" },
  1312. /* BTJZ 40 */   { DSTMASK , DSTA, 
  1313.         "17;[1=].8I;[3=].Q.1+-r" },
  1314. /* BTJZ 41 */   { DSTMASK , DSTB, 
  1315.         "37;[1=].8I;[3=].Q.1+-r" },
  1316. /* BTJZ 42 */   { 0 , 0, 
  1317.         "47;[1=].8I;[2=].8I;[3=].Q.1+-r" },
  1318. /* BTJZ 43 */   { DSTMASK , DSTA, 
  1319.         "27;[1=];[3=].Q.1+-r" },
  1320. /* BTJZ 44 */   { DSTMASK , DSTB, 
  1321.         "57;[1=];[3=].Q.1+-r" },
  1322. /* BTJZ 45 */   { 0 , 0, 
  1323.         "77;[1=];[2=].8I;[3=].Q.1+-r" },
  1324. /* BTJZP 46 */   { SRCMASK , SRCA, 
  1325.         "87;[2=].100-.8I;[3=].Q.1+-r" },
  1326. /* BTJZP 47 */   { SRCMASK , SRCB, 
  1327.         "97;[2=].100-.8I;[3=].Q.1+-r" },
  1328. /* BTJZP 48 */   { 0 , 0, 
  1329.         "a7;[1=];[2=].100-.8I;[3=].Q.1+-r" },
  1330. /* CALL 49 */   { 0 , 0, 
  1331.         "8e;[1=]x" },
  1332. /* CALL 50 */   { SRCMASK , SRCB, 
  1333.         "ae;[1=]x" },
  1334. /* CALL 51 */   { 0 , 0, 
  1335.         "9e;[1=].8I;" },
  1336. /* CLR 52 */   { DSTMASK , DSTA, 
  1337.         "b5;" },
  1338. /* CLR 53 */   { DSTMASK , DSTB, 
  1339.         "c5;" },
  1340. /* CLR 54 */   { 0 , 0, 
  1341.         "d5;[1=].8I;" },
  1342. /* CLRC 55 */   { 0 , 0, 
  1343.         "b0;" },
  1344. /* CMP 56 */   { SRCMASK|DSTMASK , SRCB|DSTA, 
  1345.         "6d;" },
  1346. /* CMP 57 */   { DSTMASK , DSTA, 
  1347.         "1d;[1=].8I;" },
  1348. /* CMP 58 */   { DSTMASK , DSTB, 
  1349.         "3d;[1=].8I;" },
  1350. /* CMP 59 */   { 0 , 0, 
  1351.         "4d;[1=].8I;[2=].8I;" },
  1352. /* CMP 60 */   { DSTMASK , DSTA, 
  1353.         "2d;[1=];" },
  1354. /* CMP 61 */   { DSTMASK , DSTB, 
  1355.         "5d;[1=];" },
  1356. /* CMP 62 */   { 0 , 0, 
  1357.         "7d;[1=];[2=].8I;" },
  1358. /* CMPA 63 */   { 0 , 0, 
  1359.         "8d;[1=]x" },
  1360. /* CMPA 64 */   { SRCMASK , SRCB, 
  1361.         "ad;[1=]x" },
  1362. /* CMPA 65 */   { 0 , 0, 
  1363.         "9d;[1=].8I;" },
  1364. /* DAC 66 */   { SRCMASK|DSTMASK , SRCB|DSTA, 
  1365.         "6e;" },
  1366. /* DAC 67 */   { DSTMASK , DSTA, 
  1367.         "1e;[1=].8I;" },
  1368. /* DAC 68 */   { DSTMASK , DSTB, 
  1369.         "3e;[1=].8I;" },
  1370. /* DAC 69 */   { 0 , 0, 
  1371.         "4e;[1=].8I;[2=].8I;" },
  1372. /* DAC 70 */   { DSTMASK , DSTA, 
  1373.         "2e;[1=];" },
  1374. /* DAC 71 */   { DSTMASK , DSTB, 
  1375.         "5e;[1=];" },
  1376. /* DAC 72 */   { 0 , 0, 
  1377.         "7e;[1=];[2=].8I;" },
  1378. /* DEC 73 */   { DSTMASK , DSTA, 
  1379.         "b2;" },
  1380. /* DEC 74 */   { DSTMASK , DSTB, 
  1381.         "c2;" },
  1382. /* DEC 75 */   { 0 , 0, 
  1383.         "d2;[1=].8I;" },
  1384. /* DECD 76 */   { DSTMASK , DSTA, 
  1385.         "bb;" },
  1386. /* DECD 77 */   { DSTMASK , DSTB, 
  1387.         "cb;" },
  1388. /* DECD 78 */   { 0 , 0, 
  1389.         "db;[1=].8I;" },
  1390. /* DINT 79 */   { 0 , 0, 
  1391.         "06;" },
  1392. /* DJNZ 80 */   { SRCMASK , SRCA, 
  1393.         "ba;[2=].Q.1+-r" },
  1394. /* DJNZ 81 */   { SRCMASK , SRCB, 
  1395.         "ca;[2=].Q.1+-r" },
  1396. /* DJNZ 82 */   { 0 , 0, 
  1397.         "da;[1=].8I;[2=].Q.1+-r" },
  1398. /* DSB 83 */   { SRCMASK|DSTMASK , SRCB|DSTA, 
  1399.         "6f;" },
  1400. /* DSB 84 */   { DSTMASK , DSTA, 
  1401.         "1f;[1=].8I;" },
  1402. /* DSB 85 */   { DSTMASK , DSTB, 
  1403.         "3f;[1=].8I;" },
  1404. /* DSB 86 */   { 0 , 0, 
  1405.         "4f;[1=].8I;[2=].8I;" },
  1406. /* DSB 87 */   { DSTMASK , DSTA, 
  1407.         "2f;[1=];" },
  1408. /* DSB 88 */   { DSTMASK , DSTB, 
  1409.         "5f;[1=];" },
  1410. /* DSB 89 */   { 0 , 0, 
  1411.         "7f;[1=];[2=].8I;" },
  1412. /* EINT 90 */   { 0 , 0, 
  1413.         "05;" },
  1414. /* IDLE 91 */   { 0 , 0, 
  1415.         "01;" },
  1416. /* INC 92 */   { DSTMASK , DSTA, 
  1417.         "b3;" },
  1418. /* INC 93 */   { DSTMASK , DSTB, 
  1419.         "c3;" },
  1420. /* INC 94 */   { 0 , 0, 
  1421.         "d3;[1=].8I;" },
  1422. /* INV 95 */   { DSTMASK , DSTA, 
  1423.         "b4;" },
  1424. /* INV 96 */   { DSTMASK , DSTB, 
  1425.         "c4;" },
  1426. /* INV 97 */   { 0 , 0, 
  1427.         "d4;[1=].8I;" },
  1428. /* JC 98 */   { 0 , 0, 
  1429.         "e3;[1=].Q.1+-r" },
  1430. /* JEQ 99 */   { 0 , 0, 
  1431.         "e2;[1=].Q.1+-r" },
  1432. /* JGE 100 */   { 0 , 0, 
  1433.         "e5;[1=].Q.1+-r" },
  1434. /* JGT 101 */   { 0 , 0, 
  1435.         "e4;[1=].Q.1+-r" },
  1436. /* JHS 102 */   { 0 , 0, 
  1437.         "e3;[1=].Q.1+-r" },
  1438. /* JL 103 */   { 0 , 0, 
  1439.         "e7;[1=].Q.1+-r" },
  1440. /* JLT 104 */   { 0 , 0, 
  1441.         "e1;[1=].Q.1+-r" },
  1442. /* JMP 105 */   { 0 , 0, 
  1443.         "e0;[1=].Q.1+-r" },
  1444. /* JN 106 */   { 0 , 0, 
  1445.         "e1;[1=].Q.1+-r" },
  1446. /* JNC 107 */   { 0 , 0, 
  1447.         "e7;[1=].Q.1+-r" },
  1448. /* JNE 108 */   { 0 , 0, 
  1449.         "e6;[1=].Q.1+-r" },
  1450. /* JNZ 109 */   { 0 , 0, 
  1451.         "e6;[1=].Q.1+-r" },
  1452. /* JP 110 */   { 0 , 0, 
  1453.         "e4;[1=].Q.1+-r" },
  1454. /* JPZ 111 */   { 0 , 0, 
  1455.         "e5;[1=].Q.1+-r" },
  1456. /* JZ 112 */   { 0 , 0, 
  1457.         "e2;[1=].Q.1+-r" },
  1458. /* LDA 113 */   { 0 , 0, 
  1459.         "8a;[1=]x" },
  1460. /* LDA 114 */   { SRCMASK , SRCB, 
  1461.         "aa;[1=]x" },
  1462. /* LDA 115 */   { 0 , 0, 
  1463.         "9a;[1=].8I;" },
  1464. /* LDSP 116 */   { 0 , 0, 
  1465.         "0d;" },
  1466. /* MOV 117 */   { SRCMASK|DSTMASK , SRCA|DSTB, 
  1467.         "c0;" },
  1468. /* MOV 118 */   { SRCMASK|DSTMASK , SRCB|DSTA, 
  1469.         "62;" },
  1470. /* MOV 119 */   { DSTMASK , DSTA, 
  1471.         "12;[1=].8I;" },
  1472. /* MOV 120 */   { SRCMASK , SRCA, 
  1473.         "d0;[2=].8I;" },
  1474. /* MOV 121 */   { SRCMASK , SRCB, 
  1475.         "d1;[2=].8I;" },
  1476. /* MOV 122 */   { DSTMASK , DSTB, 
  1477.         "32;[1=].8I;" },
  1478. /* MOV 123 */   { 0 , 0, 
  1479.         "42;[1=].8I;[2=].8I;" },
  1480. /* MOV 124 */   { DSTMASK , DSTA, 
  1481.         "22;[1=];" },
  1482. /* MOV 125 */   { DSTMASK , DSTB, 
  1483.         "52;[1=];" },
  1484. /* MOV 126 */   { 0 , 0, 
  1485.         "72;[1=];[2=].8I;" },
  1486. /* MOVD 127 */   { 0 , 0, 
  1487.         "98;[1=].8I;[2=].8I;" },
  1488. /* MOVD 128 */   { 0 , 0, 
  1489.         "88;[1=]x[2=].8I;" },
  1490. /* MOVD 129 */   { SRCMASK , SRCB, 
  1491.         "a8;[1=]x[2=].8I;" },
  1492. /* MOVP 130 */   { SRCMASK , SRCA, 
  1493.         "82;[2=].100-.8I;" },
  1494. /* MOVP 131 */   { SRCMASK , SRCB, 
  1495.         "92;[2=].100-.8I;" },
  1496. /* MOVP 132 */   { DSTMASK , DSTA, 
  1497.         "80;[1=].100-.8I;" },
  1498. /* MOVP 133 */   { DSTMASK , DSTB, 
  1499.         "91;[1=].100-.8I;" },
  1500. /* MOVP 134 */   { 0 , 0, 
  1501.         "a2;[1=];[2=].100-.8I;" },
  1502. /* MPY 135 */   { SRCMASK|DSTMASK , SRCB|DSTA, 
  1503.         "6c;" },
  1504. /* MPY 136 */   { DSTMASK , DSTA, 
  1505.         "1c;[1=].8I;" },
  1506. /* MPY 137 */   { DSTMASK , DSTB, 
  1507.         "3c;[1=].8I;" },
  1508. /* MPY 138 */   { 0 , 0, 
  1509.         "4c;[1=].8I;[2=].8I;" },
  1510. /* MPY 139 */   { DSTMASK , DSTA, 
  1511.         "2c;[1=];" },
  1512. /* MPY 140 */   { DSTMASK , DSTB, 
  1513.         "5c;[1=];" },
  1514. /* MPY 141 */   { 0 , 0, 
  1515.         "7c;[1=];[2=].8I;" },
  1516. /* NOP 142 */   { 0 , 0, 
  1517.         "00;" },
  1518. /* OR 143 */   { SRCMASK|DSTMASK , SRCB|DSTA, 
  1519.         "64;" },
  1520. /* OR 144 */   { DSTMASK , DSTA, 
  1521.         "14;[1=].8I;" },
  1522. /* OR 145 */   { DSTMASK , DSTB, 
  1523.         "34;[1=].8I;" },
  1524. /* OR 146 */   { 0 , 0, 
  1525.         "44;[1=].8I;[2=].8I;" },
  1526. /* OR 147 */   { DSTMASK , DSTA, 
  1527.         "24;[1=];" },
  1528. /* OR 148 */   { DSTMASK , DSTB, 
  1529.         "54;[1=];" },
  1530. /* OR 149 */   { 0 , 0, 
  1531.         "74;[1=];[2=].8I;" },
  1532. /* ORP 150 */   { SRCMASK , SRCA, 
  1533.         "84;[2=].100-.8I;" },
  1534. /* ORP 151 */   { SRCMASK , SRCB, 
  1535.         "94;[2=].100-.8I;" },
  1536. /* ORP 152 */   { 0 , 0, 
  1537.         "a4;[1=];[2=].100-.8I;" },
  1538. /* POP 153 */   { DSTMASK , DSTA, 
  1539.         "b9;" },
  1540. /* POP 154 */   { DSTMASK , DSTB, 
  1541.         "c9;" },
  1542. /* POP 155 */   { 0 , 0, 
  1543.         "d9;[1=].8I;" },
  1544. /* POP 156 */   { 0 , 0, 
  1545.         "08;" },
  1546. /* PUSH 157 */   { DSTMASK , DSTA, 
  1547.         "b8;" },
  1548. /* PUSH 158 */   { DSTMASK , DSTB, 
  1549.         "c8;" },
  1550. /* PUSH 159 */   { 0 , 0, 
  1551.         "d8;[1=].8I;" },
  1552. /* PUSH 160 */   { 0 , 0, 
  1553.         "0e;" },
  1554. /* RETI 161 */   { 0 , 0, 
  1555.         "0b;" },
  1556. /* RETS 162 */   { 0 , 0, 
  1557.         "0a;" },
  1558. /* RL 163 */   { DSTMASK , DSTA, 
  1559.         "be;" },
  1560. /* RL 164 */   { DSTMASK , DSTB, 
  1561.         "ce;" },
  1562. /* RL 165 */   { 0 , 0, 
  1563.         "de;[1=].8I;" },
  1564. /* RLC 166 */   { DSTMASK , DSTA, 
  1565.         "bf;" },
  1566. /* RLC 167 */   { DSTMASK , DSTB, 
  1567.         "cf;" },
  1568. /* RLC 168 */   { 0 , 0, 
  1569.         "df;[1=].8I;" },
  1570. /* RR 169 */   { DSTMASK , DSTA, 
  1571.         "bc;" },
  1572. /* RR 170 */   { DSTMASK , DSTB, 
  1573.         "cc;" },
  1574. /* RR 171 */   { 0 , 0, 
  1575.         "dc;[1=].8I;" },
  1576. /* RRC 172 */   { DSTMASK , DSTA, 
  1577.         "bd;" },
  1578. /* RRC 173 */   { DSTMASK , DSTB, 
  1579.         "cd;" },
  1580. /* RRC 174 */   { 0 , 0, 
  1581.         "dd;[1=].8I;" },
  1582. /* SBB 175 */   { SRCMASK|DSTMASK , SRCB|DSTA, 
  1583.         "6b;" },
  1584. /* SBB 176 */   { DSTMASK , DSTA, 
  1585.         "1b;[1=].8I;" },
  1586. /* SBB 177 */   { DSTMASK , DSTB, 
  1587.         "3b;[1=].8I;" },
  1588. /* SBB 178 */   { 0 , 0, 
  1589.         "4b;[1=].8I;[2=].8I;" },
  1590. /* SBB 179 */   { DSTMASK , DSTA, 
  1591.         "2b;[1=];" },
  1592. /* SBB 180 */   { DSTMASK , DSTB, 
  1593.         "5b;[1=];" },
  1594. /* SBB 181 */   { 0 , 0, 
  1595.         "7b;[1=];[2=].8I;" },
  1596. /* SETC 182 */   { 0 , 0, 
  1597.         "07;" },
  1598. /* STA 183 */   { 0 , 0, 
  1599.         "8b;[1=]x" },
  1600. /* STA 184 */   { SRCMASK , SRCB, 
  1601.         "ab;[1=]x" },
  1602. /* STA 185 */   { 0 , 0, 
  1603.         "9b;[1=].8I;" },
  1604. /* STSP 186 */   { 0 , 0, 
  1605.         "09;" },
  1606. /* SUB 187 */   { SRCMASK|DSTMASK , SRCB|DSTA, 
  1607.         "6a;" },
  1608. /* SUB 188 */   { DSTMASK , DSTA, 
  1609.         "1a;[1=].8I;" },
  1610. /* SUB 189 */   { DSTMASK , DSTB, 
  1611.         "3a;[1=].8I;" },
  1612. /* SUB 190 */   { 0 , 0, 
  1613.         "4a;[1=].8I;[2=].8I;" },
  1614. /* SUB 191 */   { DSTMASK , DSTA, 
  1615.         "2a;[1=];" },
  1616. /* SUB 192 */   { DSTMASK , DSTB, 
  1617.         "5a;[1=];" },
  1618. /* SUB 193 */   { 0 , 0, 
  1619.         "7a;[1=];[2=].8I;" },
  1620. /* SWAP 194 */   { DSTMASK , DSTA, 
  1621.         "b7;" },
  1622. /* SWAP 195 */   { DSTMASK , DSTB, 
  1623.         "c7;" },
  1624. /* SWAP 196 */   { 0 , 0, 
  1625.         "d7;[1=].8I;" },
  1626. /* TRAP 197 */   { 0 , 0, 
  1627.         "ff.[1=].5I-~.e8<T!;" },
  1628. /* TSTA 198 */   { 0 , 0, 
  1629.         "b0;" },
  1630. /* TSTB 199 */   { 0 , 0, 
  1631.         "c1;" },
  1632. /* XCHB 200 */   { DSTMASK , DSTA, 
  1633.         "b6;" },
  1634. /* XCHB 201 */   { DSTMASK , DSTB, 
  1635.         "c6;" },
  1636. /* XCHB 202 */   { 0 , 0, 
  1637.         "d6;[1=].8I;" },
  1638. /* XOR 203 */   { SRCMASK|DSTMASK , SRCB|DSTA, 
  1639.         "65;" },
  1640. /* XOR 204 */   { DSTMASK , DSTA, 
  1641.         "15;[1=].8I;" },
  1642. /* XOR 205 */   { DSTMASK , DSTB, 
  1643.         "35;[1=].8I;" },
  1644. /* XOR 206 */   { 0 , 0, 
  1645.         "45;[1=].8I;[2=].8I;" },
  1646. /* XOR 207 */   { DSTMASK , DSTA, 
  1647.         "25;[1=];" },
  1648. /* XOR 208 */   { DSTMASK , DSTB, 
  1649.         "55;[1=];" },
  1650. /* XOR 209 */   { 0 , 0, 
  1651.         "75;[1=];[2=].8I;" },
  1652. /* XORP 210 */   { SRCMASK , SRCA, 
  1653.         "85;[2=].100-.8I;" },
  1654. /* XORP 211 */   { SRCMASK , SRCB, 
  1655.         "95;[2=].100-.8I;" },
  1656. /* XORP 212 */   { 0 , 0, 
  1657.         "a5;[1=];[2=].100-.8I;" },
  1658.     { 0,0,""} };
  1659. /* end fraptabdef.c */
  1660.